package gestorBD;

import gestorHotel.*;
import gestorHotel.reserva.*;
import gestorHotel.factura.*;
import gestorHotel.habitacion.*;
import gestorHotel.servicios.*;
import gestorHotel.usuarios.*;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.*;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class GestorBD {
	
	private String xmlFile = "app.xml";

	public GestorBD() { }
	
	public HashMap<String, Usuario> getUsuarios() {
		HashMap<String, Usuario> usuarios = new HashMap<String, Usuario>();
		
		try {
			File fXmlFile = new File(xmlFile);
			
			if (fXmlFile.exists()) {
				DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
				Document doc = dBuilder.parse(fXmlFile);
		     
		    	doc.getDocumentElement().normalize();
		    				
				NodeList nList = doc.getElementsByTagName("usuario");
		
		    	for (int i = 0; i < nList.getLength(); ++i) {
		    		Node nNode = nList.item(i);
		    		if (nNode.getNodeType() == Node.ELEMENT_NODE) {
		    			Element e = (Element) nNode;
		     
		    			String nombre = e.getElementsByTagName("nombreU").item(0).getTextContent();
		    			String primerApellido = e.getElementsByTagName("primerApellido").item(0).getTextContent();
		    			String segundoApellido = e.getElementsByTagName("segundoApellido").item(0).getTextContent();
		    			String telefono = e.getElementsByTagName("telefonoU").item(0).getTextContent();
		    			String email = e.getElementsByTagName("email").item(0).getTextContent();
		    			String DNI = e.getElementsByTagName("DNI").item(0).getTextContent();
		    			String direccion = e.getElementsByTagName("direccionU").item(0).getTextContent();
		    			String numTarjeta = e.getElementsByTagName("numTarjeta").item(0).getTextContent();
		    			String usuario = e.getElementsByTagName("nUsuario").item(0).getTextContent();
		    			String clave = e.getElementsByTagName("clave").item(0).getTextContent();
		    			String tipo = e.getElementsByTagName("tipoU").item(0).getTextContent();
		    			
		    			Usuario u = new Usuario(nombre, primerApellido, segundoApellido, 
		    				       telefono, email, DNI, direccion, numTarjeta, usuario, clave, tipo);
		    			
		    			usuarios.put(usuario, u);
		    		}
		    	}
			}
		} catch (Exception e) {
	    	e.printStackTrace();
			System.out.println("Error: No se pudo encontrar el usuario en la base de datos!");
	    }
    	
    	return usuarios;
	}
	
	public void escribirXML(HashMap<String, Usuario> usuarios, HashMap<String, Hotel> hoteles) {
		try {
			 
			DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
	 
			// root elements
			Document doc = docBuilder.newDocument();
			
			Element rootElement = doc.createElement("cadenaHotelera");
			doc.appendChild(rootElement);
	 
			for (Usuario u : usuarios.values()) {
				Element eUsuario = doc.createElement("usuario");
				rootElement.appendChild(eUsuario);
				
				eUsuario.setAttribute("id", u.getUsuario());
				
				escribirCampo(doc, eUsuario, "nombreU", u.getNombre());
				escribirCampo(doc, eUsuario, "primerApellido", u.getPrimerApellido());
				escribirCampo(doc, eUsuario, "segundoApellido", u.getSegundoApellido());
				escribirCampo(doc, eUsuario, "telefonoU", u.getTelefono());
				escribirCampo(doc, eUsuario, "email", u.getEmail());
				escribirCampo(doc, eUsuario, "DNI", u.getDNI());
				escribirCampo(doc, eUsuario, "direccionU", u.getDireccion());
				escribirCampo(doc, eUsuario, "numTarjeta", u.getNumTarjeta());
				escribirCampo(doc, eUsuario, "nUsuario", u.getUsuario());
				escribirCampo(doc, eUsuario, "clave", u.getClave());
				escribirCampo(doc, eUsuario, "tipoU", u.getTipo());
			}
			
			for (Hotel h : hoteles.values()) {
				Element eHotel = doc.createElement("hotel");
				rootElement.appendChild(eHotel);
				
				eHotel.setAttribute("id", h.getNombre());
				
				escribirCampo(doc, eHotel, "nombreH", h.getNombre());
				escribirCampo(doc, eHotel, "direccionH", h.getDireccion());
				escribirCampo(doc, eHotel, "poblacion", h.getPoblacion());
				escribirCampo(doc, eHotel, "provincia", h.getProvincia());
				escribirCampo(doc, eHotel, "pais", h.getPais());
				escribirCampo(doc, eHotel, "numEstrellas", String.valueOf(h.getNumEstrellas()));
				
				for (Habitacion habitacion : h.getHabitaciones().values()) {
					Element eHab = doc.createElement("habitacion");
					eHotel.appendChild(eHab);
					
					eHab.setAttribute("id", String.valueOf(habitacion.getNumero()));
					
					escribirCampo(doc, eHab, "numeroH", String.valueOf(habitacion.getNumero()));
					escribirCampo(doc, eHab, "estadoH", habitacion.getEstado().toString());
					escribirCampo(doc, eHab, "minutosNacionales", String.valueOf(habitacion.getMinutosNacionales()));
					escribirCampo(doc, eHab, "minutosInternacionales", String.valueOf(habitacion.getMinutosInternacionales()));
					escribirCampo(doc, eHab, "minutosInternet", String.valueOf(habitacion.getMinutosInternet()));
					escribirCampo(doc, eHab, "tipoH", habitacion.getTipo());
					escribirCampo(doc, eHab, "categoriaH", habitacion.getCategoria());

					for (int k = 0; k < habitacion.getMinibar().size(); ++k) {
						Minibar minibar = habitacion.getMinibar().get(k);
						Element eBar = doc.createElement("minibar");
						eHab.appendChild(eBar);
						
						eBar.setAttribute("id", String.valueOf(k + 1));
						
						escribirCampo(doc, eBar, "cantidadM", String.valueOf(minibar.getCantidad()));
						escribirCampo(doc, eBar, "bebidaM", minibar.getBebidas());
					}
				}
				
				for (Tipo tipo : h.getTipos().values()) {
					Element eTipo = doc.createElement("tipo");
					eHotel.appendChild(eTipo);
					
					eTipo.setAttribute("id", tipo.getNombre());
					
					escribirCampo(doc, eTipo, "nombreT", tipo.getNombre());
					escribirCampo(doc, eTipo, "precioT", String.valueOf(tipo.getPrecio()));
				}
				
				for (Categoria categoria : h.getCategorias().values()) {
					Element eCat = doc.createElement("categoria");
					eHotel.appendChild(eCat);
					
					eCat.setAttribute("id", categoria.getNombre());
					
					escribirCampo(doc, eCat, "nombreC", categoria.getNombre());
					escribirCampo(doc, eCat, "suplemento", String.valueOf(categoria.getSuplemento()));
				}
    			
				for (ServicioComunicacion servicio : h.getServicios().values()) {
					Element eServicio = doc.createElement("servicio");
					eHotel.appendChild(eServicio);
					
					eServicio.setAttribute("id", servicio.getNombre());
					
					escribirCampo(doc, eServicio, "nombreS", servicio.getNombre());
					escribirCampo(doc, eServicio, "precioS", String.valueOf(servicio.getPrecio()));
				}
    			
				for (Bebida bebida : h.getBebidas().values()) {
					Element eBebida = doc.createElement("bebida");
					eHotel.appendChild(eBebida);
					
					eBebida.setAttribute("id", bebida.getNombre());
					
					escribirCampo(doc, eBebida, "nombreB", bebida.getNombre());
					escribirCampo(doc, eBebida, "marca", bebida.getMarca());
					escribirCampo(doc, eBebida, "precioB", String.valueOf(bebida.getPrecio()));
					escribirCampo(doc, eBebida, "disponibilidad", String.valueOf(bebida.getDisponibilidad()));
				}
				
				RestriccionReserva rest = h.getRestriccion();
				Element eRest = doc.createElement("restriccion");
				eHotel.appendChild(eRest);

				escribirCampo(doc, eRest, "maxMesAdelanto", String.valueOf(rest.getMaxMesAdelanto()));
				escribirCampo(doc, eRest, "maxDuracion", String.valueOf(rest.getMaxDuracion()));
			
				for (int k = 0; k < h.getPenalizaciones().size(); ++k) {
					PenalizacionCancelacion pena = h.getPenalizaciones().get(k);
					Element ePena = doc.createElement("penalizacion");
					eHotel.appendChild(ePena);
					
					ePena.setAttribute("id", String.valueOf(k + 1));

					escribirCampo(doc, ePena, "coste", String.valueOf(pena.getCoste()));
					escribirCampo(doc, ePena, "antesDe", String.valueOf(pena.getAntesDe()));
				}
				
				for (Reserva reserva : h.getReservas().values()) {
					Element eReserva = doc.createElement("reserva");
					eHotel.appendChild(eReserva);
					
					eReserva.setAttribute("id", String.valueOf(reserva.getCodReserva()));
					
					escribirCampo(doc, eReserva, "fechaEntrada", reserva.getFechaEntrada());
					escribirCampo(doc, eReserva, "fechaReserva", reserva.getFechaReserva());
					escribirCampo(doc, eReserva, "numNoches", String.valueOf(reserva.getNumNoches()));
					escribirCampo(doc, eReserva, "estadoR", reserva.getEstado().toString());
					escribirCampo(doc, eReserva, "numPersonas", String.valueOf(reserva.getNumPersonas()));
					escribirCampo(doc, eReserva, "usuarioR", reserva.getUsuario());
					escribirCampo(doc, eReserva, "codReserva", String.valueOf(reserva.getCodReserva()));
					
					for (int k = 0; k < reserva.getLineas().size(); ++k) {
						LineaReserva lineaR = reserva.getLineas().get(k);
						Element eLineaR = doc.createElement("lineaReserva");
						eReserva.appendChild(eLineaR);
						
						eLineaR.setAttribute("id", String.valueOf(k + 1));
						
						escribirCampo(doc, eLineaR, "cantidadLR", String.valueOf(lineaR.getCantidad()));
						escribirCampo(doc, eLineaR, "supletoriaLR", lineaR.isSupletoria() ? "TRUE" : "FALSE");
						escribirCampo(doc, eLineaR, "habitacionLR", String.valueOf(lineaR.getHabitacion()));
					}
					
					if (reserva.getFactura() != null) {
					
						Element eFactura = doc.createElement("factura");
						eReserva.appendChild(eFactura);
						
						escribirCampo(doc, eFactura, "precioTotal", String.valueOf(reserva.getFactura().getPrecioTotal()));
						escribirCampo(doc, eFactura, "fecha", String.valueOf(reserva.getFactura().getFecha()));
						
						for (int k = 0; k < reserva.getFactura().getLineas().size(); ++k) {
							LineaFactura lineaF = reserva.getFactura().getLineas().get(k);
							Element eLineaF = doc.createElement("lineaFactura");
							eFactura.appendChild(eLineaF);
							
							eLineaF.setAttribute("id", String.valueOf(k + 1));
							
							escribirCampo(doc, eLineaF, "conceptoLF", lineaF.getConcepto());
							escribirCampo(doc, eLineaF, "cantidadLF", String.valueOf(lineaF.getCantidad()));
							escribirCampo(doc, eLineaF, "precioUnitario", String.valueOf(lineaF.getPrecioUnitario()));
						}
					}
				}
			}
	 
			// write the content into xml file
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			DOMSource source = new DOMSource(doc);
			StreamResult result = new StreamResult(new File(xmlFile));
	 
			// Output to console for testing
			// StreamResult result = new StreamResult(System.out);
	 
			transformer.transform(source, result);
	 
			System.out.println("Archivo XML guardado!");
	 
		  } catch (ParserConfigurationException pce) {
			  pce.printStackTrace();
		  } catch (TransformerException tfe) {
			  tfe.printStackTrace();
		  }
	}
	
	public HashMap<String, Hotel> getHoteles() {
		HashMap<String, Hotel> hoteles = new HashMap<String, Hotel>();
		
		try {
			File fXmlFile = new File(xmlFile);
			
			if (fXmlFile.exists()) {
				DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
				Document doc = dBuilder.parse(fXmlFile);
		     
		    	doc.getDocumentElement().normalize();
		    				
				NodeList nList = doc.getElementsByTagName("hotel");
		
		    	for (int i = 0; i < nList.getLength(); ++i) {
		    		Node nNode = nList.item(i);
		    		if (nNode.getNodeType() == Node.ELEMENT_NODE) {
		    			System.out.println("Cargando hotel...");
		    			Element e = (Element) nNode;
		     
		    			String nombre = e.getElementsByTagName("nombreH").item(0).getTextContent();
		    			String direccion = e.getElementsByTagName("direccionH").item(0).getTextContent();
		    			String poblacion = e.getElementsByTagName("poblacion").item(0).getTextContent();
		    			String provincia = e.getElementsByTagName("provincia").item(0).getTextContent();
		    			String pais = e.getElementsByTagName("pais").item(0).getTextContent();
		    			int numEstrellas = Integer.parseInt(e.getElementsByTagName("numEstrellas").item(0).getTextContent());
		    			
		    			HashMap<Integer, Habitacion> habitaciones = new HashMap<Integer, Habitacion>();
		    			HashMap<String, Tipo> tipos = new HashMap<String, Tipo>();
		    			HashMap<String, Categoria> categorias = new HashMap<String, Categoria>();
		    			HashMap<String, ServicioComunicacion> servicios = new HashMap<String, ServicioComunicacion>();
		    			HashMap<String, Bebida> bebidas = new HashMap<String, Bebida>();
		    			RestriccionReserva restriccion = null;
		    			ArrayList<PenalizacionCancelacion> penalizaciones = new ArrayList<PenalizacionCancelacion>();
		    			HashMap<Integer, Reserva> reservas = new HashMap<Integer, Reserva>();
		    			
		    			NodeList habList = e.getElementsByTagName("habitacion");
		    			for (int j = 0; j < habList.getLength(); ++j) {
		    				Node habNode = habList.item(j);
		    	    		if (habNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando habitación...");
		    	    			Element eHab = (Element) habNode;
		    	    			
		    	    			int numero = Integer.parseInt(eHab.getElementsByTagName("numeroH").item(0).getTextContent());
		    	    			String strEstado = eHab.getElementsByTagName("estadoH").item(0).getTextContent();
		    	    			int minutosNacionales = Integer.parseInt(eHab.getElementsByTagName("minutosNacionales").item(0).getTextContent());;
		    	    			int minutosInternacionales = Integer.parseInt(eHab.getElementsByTagName("minutosInternacionales").item(0).getTextContent());;
		    	    			int minutosInternet = Integer.parseInt(eHab.getElementsByTagName("minutosInternet").item(0).getTextContent());
		    	    			String tipo = eHab.getElementsByTagName("tipoH").item(0).getTextContent();
		    	    			String categoria = eHab.getElementsByTagName("categoriaH").item(0).getTextContent();
		    	    			
		    	    			TipoEstadoHabitacion estado = null;
		    	    			if (strEstado.equals("LIBRE"))
		    	    				estado = TipoEstadoHabitacion.LIBRE;
		    	    			else if (strEstado.equals("OCUPADA"))
		    	    				estado = TipoEstadoHabitacion.OCUPADA;
		    	    			else if (strEstado.equals("RESERVADA"))
		    	    				estado = TipoEstadoHabitacion.RESERVADA;
		    	    			
		    	    			ArrayList<Minibar> minibar = new ArrayList<Minibar>();
		    	    			
		    	    			NodeList barList = e.getElementsByTagName("minibar");
		    	    			for (int k = 0; k < barList.getLength(); ++k) {
		    	    				Node barNode = barList.item(k);
		    	    	    		if (barNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    	    			System.out.println("Cargando minibar...");
		    	    	    			Element eBar = (Element) barNode;
		    	    	    			
		    	    	    			int cantidad = Integer.parseInt(eBar.getElementsByTagName("cantidadM").item(0).getTextContent());
		    	    	    			String bebida = eBar.getElementsByTagName("bebidaM").item(0).getTextContent();
		    	    	    			
		    	    	    			minibar.add(new Minibar(bebida, cantidad));
		    	    	    		}
		    	    			}
		    	    			
		    	    			habitaciones.put(numero, new Habitacion(numero, estado, minutosNacionales, 
		    	    					minutosInternacionales, minutosInternet, tipo, categoria, minibar));
		    	    		}
		    			}
	
		    			NodeList tipoList = e.getElementsByTagName("tipo");
		    			for (int j = 0; j < tipoList.getLength(); ++j) {
		    				Node tipoNode = tipoList.item(j);
		    	    		if (tipoNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando tipo de habitación...");
		    	    			Element eTipo = (Element) tipoNode;
		    	    			
		    	    			String nombreTipo = eTipo.getElementsByTagName("nombreT").item(0).getTextContent();
		    	    			double precio = Double.parseDouble(eTipo.getElementsByTagName("precioT").item(0).getTextContent());
		    	    			
		    	    			tipos.put(nombreTipo, new Tipo(nombreTipo, precio));
		    	    		}
		    			}
		    			
		    			NodeList catList = e.getElementsByTagName("categoria");
		    			for (int j = 0; j < catList.getLength(); ++j) {
		    				Node catNode = catList.item(j);
		    	    		if (catNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando categoría de habitación...");
		    	    			Element eCat = (Element) catNode;
		    	    			
		    	    			String nombreCat = eCat.getElementsByTagName("nombreC").item(0).getTextContent();
		    	    			double suplemento = Double.parseDouble(eCat.getElementsByTagName("suplemento").item(0).getTextContent());
		    	    			
		    	    			categorias.put(nombreCat, new Categoria(nombreCat, suplemento));
		    	    		}
		    			}
		    			
		    			NodeList servList = e.getElementsByTagName("servicio");
		    			for (int j = 0; j < servList.getLength(); ++j) {
		    				Node servNode = servList.item(j);
		    	    		if (servNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando servicio de habitación...");
		    	    			Element eServ = (Element) servNode;
		    	    			
		    	    			String nombreServicio = eServ.getElementsByTagName("nombreS").item(0).getTextContent();
		    	    			double precio = Double.parseDouble(eServ.getElementsByTagName("precioS").item(0).getTextContent());
		    	    			
		    	    			servicios.put(nombreServicio, new ServicioComunicacion(nombreServicio, precio));
		    	    		}
		    			}
		    			
		    			NodeList bebidaList = e.getElementsByTagName("bebida");
		    			for (int j = 0; j < bebidaList.getLength(); ++j) {
		    				Node bebidaNode = bebidaList.item(j);
		    	    		if (bebidaNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando bebida...");
		    	    			Element eBebida = (Element) bebidaNode;
		    	    			
		    	    			String nombreBebida = eBebida.getElementsByTagName("nombreB").item(0).getTextContent();
		    	    			String marca = eBebida.getElementsByTagName("marca").item(0).getTextContent();
		    	    			double precio = Double.parseDouble(eBebida.getElementsByTagName("precioB").item(0).getTextContent());
		    	    			int disponibilidad = Integer.parseInt(eBebida.getElementsByTagName("disponibilidad").item(0).getTextContent());
	
		    	    			bebidas.put(nombreBebida, new Bebida(nombreBebida, marca, precio, disponibilidad));
		    	    		}
		    			}
		    			
		    			NodeList restList = e.getElementsByTagName("restriccion");
		    			if (restList.getLength() > 0) {
			    			Node restNode = restList.item(0);
		    	    		if (restNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando restricción...");
		    	    			Element eRest = (Element) restNode;
		    	    			
		    	    			int maxMesAdelanto = Integer.parseInt(eRest.getElementsByTagName("maxMesAdelanto").item(0).getTextContent());
		    	    			int maxDuracion = Integer.parseInt(eRest.getElementsByTagName("maxDuracion").item(0).getTextContent());
		    	    			
		    	    			restriccion = new RestriccionReserva(maxMesAdelanto, maxDuracion);
		    	    		}
		    			}
		    			
	    	    		NodeList penaList = e.getElementsByTagName("penalizacion");
		    			for (int j = 0; j < penaList.getLength(); ++j) {
		    				Node penaNode = penaList.item(j);
		    	    		if (penaNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando penalización...");
		    	    			Element ePena = (Element) penaNode;
		    	    			
		    	    			double coste = Double.parseDouble(ePena.getElementsByTagName("coste").item(0).getTextContent());
		    	    			int antesDe = Integer.parseInt(ePena.getElementsByTagName("antesDe").item(0).getTextContent());
	
		    	    			penalizaciones.add(new PenalizacionCancelacion(coste, antesDe));
		    	    		}
		    			}
		    			
		    			NodeList reservaList = e.getElementsByTagName("reserva");
		    			for (int j = 0; j < reservaList.getLength(); ++j) {
		    				Node reservaNode = reservaList.item(j);
		    	    		if (reservaNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    			System.out.println("Cargando reserva...");
		    	    			Element eReserva = (Element) reservaNode;
		    	    			
		    	    			String fechaEntrada = eReserva.getElementsByTagName("fechaEntrada").item(0).getTextContent();
		    	    			String fechaReserva = eReserva.getElementsByTagName("fechaReserva").item(0).getTextContent();
		    	    			int numNoches = Integer.parseInt(eReserva.getElementsByTagName("numNoches").item(0).getTextContent());
		    	    			String strEstado = eReserva.getElementsByTagName("estadoR").item(0).getTextContent();
		    	    			int numPersonas = Integer.parseInt(eReserva.getElementsByTagName("numPersonas").item(0).getTextContent());
		    	    			String usuario = eReserva.getElementsByTagName("usuarioR").item(0).getTextContent();
		    	    			int codReserva = Integer.parseInt(eReserva.getElementsByTagName("codReserva").item(0).getTextContent());
		    	    			
		    	    			TipoEstadoReserva estado = null;
		    	    			if (strEstado.equals("ACTIVA"))
		    	    				estado = TipoEstadoReserva.ACTIVA;
		    	    			else if (strEstado.equals("CANCELADA"))
		    	    				estado = TipoEstadoReserva.CANCELADA;
		    	    			else if (strEstado.equals("CERRADA"))
		    	    				estado = TipoEstadoReserva.CERRADA;
		    	    			else if (strEstado.equals("PENDIENTE"))
		    	    				estado = TipoEstadoReserva.PENDIENTE;
		    	    			
		    	    			ArrayList<LineaReserva> lineas = new ArrayList<LineaReserva>();
		    	    			Factura factura = null;
	
		    	    			NodeList lineaRList = eReserva.getElementsByTagName("lineaReserva");
		    	    			for (int k = 0; k < lineaRList.getLength(); ++k) {
		    	    				Node lineaRNode = lineaRList.item(k);
		    	    	    		if (lineaRNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    	    			System.out.println("Cargando línea de reserva...");
		    	    	    			Element eLineaR = (Element) lineaRNode;
		    	    	    			
		    	    	    			int cantidad = Integer.parseInt(eLineaR.getElementsByTagName("cantidadLR").item(0).getTextContent());
		    	    	    			boolean supletoria = eLineaR.getElementsByTagName("supletoriaLR").item(0).getTextContent().equals("TRUE") ? true : false;
		    	    	    			int habitacion = Integer.parseInt(eLineaR.getElementsByTagName("habitacionLR").item(0).getTextContent());
	
		    	    	    			lineas.add(new LineaReserva(cantidad, supletoria, habitacion));
		    	    	    		}
		    	    			}
		    	    			
		    	    			NodeList facturaList = eReserva.getElementsByTagName("factura");
		    	    			if (facturaList.getLength() > 0) {
			    	    			Node facturaNode = facturaList.item(0);
		    	    	    		if (facturaNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    	    			System.out.println("Cargando factura...");
		    	    	    			Element eFactura = (Element) facturaNode;
		    	    	    			
		    	    	    			factura = new Factura();
		    	    	    			
		    	    	    			double precioTotal = Double.parseDouble(eFactura.getElementsByTagName("precioTotal").item(0).getTextContent());
		    	    	    			String strFecha = eFactura.getElementsByTagName("fecha").item(0).getTextContent();

		    	    	    			factura.setPrecioTotal(precioTotal);
		    	    	    			factura.setFecha(strFecha);
		
		    	    	    			NodeList lineaFList = eReserva.getElementsByTagName("lineaFactura");
		    	    	    			for (int k = 0; k < lineaFList.getLength(); ++k) {
		    	    	    				Node lineaFNode = lineaFList.item(k);
		    	    	    	    		if (lineaFNode.getNodeType() == Node.ELEMENT_NODE) {
		    	    	    	    			System.out.println("Cargando línea de factura...");
		    	    	    	    			Element eLineaF = (Element) lineaFNode;
		    	    	    	    			
		    	    	    	    			String concepto = eLineaF.getElementsByTagName("conceptoLF").item(0).getTextContent();
		    	    	    	    			int cantidad = Integer.parseInt(eLineaF.getElementsByTagName("cantidadLF").item(0).getTextContent());
		    	    	    	    			double precioUnitario = Double.parseDouble(eLineaF.getElementsByTagName("precioUnitario").item(0).getTextContent());
		    	    	    	    			
		    	    	    	    			factura.agregarLinea(concepto, cantidad, precioUnitario);
		    	    	    	    		}
		    	    	    			}
		    	    	    		}
	    	    	    		}
		    	    			
		    	    			reservas.put(codReserva, new Reserva(fechaEntrada, fechaReserva, numNoches, 
		    	    					estado, numPersonas, lineas, usuario, codReserva, factura));
		    	    		}
		    			}
		    			
		    			Hotel h = new Hotel(nombre, direccion, poblacion, provincia, pais, numEstrellas,
		    					penalizaciones, restriccion, servicios, bebidas, habitaciones,
		    					reservas, tipos, categorias);
		    			
		    			hoteles.put(nombre, h);
		    		}
		    	}
	    	}
		} catch (Exception e) {
	    	e.printStackTrace();
	    }
    	
    	return hoteles;
	}
	
	public void escribirCampo(Document doc, Element p, String campo, String valor) {
		Element e = doc.createElement(campo);
		e.appendChild(doc.createTextNode(valor));
		p.appendChild(e);
	}
}
